home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / Resources / CutePDF 2.3 / converter.exe / GNUGS / GS_LEV2.PS < prev    next >
Text File  |  2003-04-01  |  32KB  |  935 lines
  1. %    Copyright (C) 1990, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_lev2.ps,v 1.7.2.4.2.2 2003/03/31 13:02:22 giles Exp $
  17. % Initialization file for Level 2 functions.
  18. % When this is run, systemdict is still writable,
  19. % but (almost) everything defined here goes into level2dict.
  20.  
  21. level2dict begin
  22.  
  23. % ------ System and user parameters ------ %
  24.  
  25. % User parameters must obey save/restore, and must also be maintained
  26. % per-context.  We implement the former, and some of the latter, here
  27. % with PostScript code.  NOTE: our implementation assumes that user
  28. % parameters change only as a result of setuserparams -- that there are
  29. % no user parameters that are ever changed dynamically by the interpreter
  30. % (although the interpreter may adjust the value presented to setuserparams)
  31. %
  32. % There are two types of user parameters: those which are actually
  33. % maintained in the interpreter, and those which exist only at the
  34. % PostScript level.  We maintain the current state of both types in
  35. % a read-only local dictionary named userparams, defined in systemdict.
  36. % In a multi-context system, each context has its own copy of this
  37. % dictionary.  In addition, there is a constant dictionary named
  38. % psuserparams where each key is the name of a user parameter that exists
  39. % only in PostScript and the value is a procedure to check that the value
  40. % is legal: setuserparams uses this for checking the values.
  41. % setuserparams updates userparams explicitly, in addition to setting
  42. % any user parameters in the interpreter; thus we can use userparams
  43. % to reset those parameters after a restore or a context switch.
  44. % NOTE: the name userparams is known to the interpreter, and in fact
  45. % the interpreter creates the userparams dictionary.
  46.  
  47. % Check parameters that are managed at the PostScript level.
  48. /.checkparamtype {        % <newvalue> <type> .checkparamtype <bool>
  49.   exch type eq
  50. } .bind def
  51. /.checksetparams {        % <newdict> <opname> <checkdict>
  52.                 %   .checksetparams <newdict>
  53.   2 index {
  54.         % Stack: newdict opname checkdict key newvalue
  55.     3 copy 3 1 roll .knownget {
  56.       exec not {
  57.     pop pop pop load /typecheck signalerror
  58.       } if
  59.       dup type /stringtype eq {
  60.     dup rcheck not {
  61.       pop pop pop load /invalidaccess signalerror
  62.     } if
  63.       } if
  64.     } {
  65.       pop
  66.     } ifelse pop pop
  67.   } forall pop pop
  68. } .bind def    % not odef, shouldn't reset stacks
  69.  
  70. % currentuser/systemparams creates and returns a dictionary in the
  71. % current VM.  The easiest way to make this work is to copy any composite
  72. % PostScript-level parameters to global VM.  Currently we have strings
  73. % as well as arrays. For arrays, we also need to copy any contents that
  74. % are in VM. Also copying string parameters insures the contents won't
  75. % be changed. Also be careful to preserve 'executable' state.
  76. /.copyparam {            % <value> .copyparam <value'>
  77.   dup type /arraytype eq {
  78.     .currentglobal true .setglobal exch 
  79.     dup xcheck exch        % original executable state
  80.     [ exch {
  81.       dup type dup /arraytype eq exch /stringtype eq or {
  82.         .copyparam    % recurse to handle composite array elements
  83.       } if
  84.     } forall ]
  85.     exch { cvx } if        % set executable state
  86.     exch .setglobal
  87.   } if
  88.   dup type /stringtype eq {
  89.     .currentglobal true .setglobal
  90.     1 index length string exch .setglobal
  91.     copy readonly
  92.   } if
  93. } .bind def
  94.  
  95. % Some user parameters are managed entirely at the PostScript level.
  96. % We take care of that here.
  97. systemdict begin
  98. /psuserparams 48 dict def
  99. /getuserparam {            % <name> getuserparam <value>
  100.   /userparams .systemvar 1 index get exch pop
  101. } odef
  102. % Fill in userparams (created by the interpreter) with current values.
  103. mark .currentuserparams
  104. counttomark 2 idiv {
  105.   userparams 3 1 roll put
  106. } repeat pop
  107. /.definepsuserparam {        % <name> <value> .definepsuserparam -
  108.   psuserparams 3 copy pop
  109.   type cvlit /.checkparamtype cvx 2 packedarray cvx put
  110.   userparams 3 1 roll put
  111. } .bind def
  112. end
  113. /currentuserparams {        % - currentuserparams <dict>
  114.   /userparams .systemvar dup length dict .copydict
  115. } odef
  116. /setuserparams {        % <dict> setuserparams -
  117.     % Check that we will be able to set the PostScript-level
  118.     % user parameters.
  119.   /setuserparams /psuserparams .systemvar .checksetparams
  120.     % Set the C-level user params.  If this succeeds, we know that
  121.     % the password check succeeded.
  122.   dup .setuserparams
  123.     % Now set the PostScript-level params.
  124.     % The interpreter may have adjusted the values of some of the
  125.     % parameters, so we have to read them back.
  126.   dup {
  127.     /userparams .systemvar 2 index known {
  128.       psuserparams 2 index known not {
  129.     pop dup .getuserparam
  130.       } if
  131.       .copyparam
  132.       /userparams .systemvar 3 1 roll .forceput  % userparams is read-only
  133.     } {
  134.       pop pop
  135.     } ifelse
  136.   } forall
  137.     % A context switch might have occurred during the above loop,
  138.     % causing the interpreter-level parameters to be reset.
  139.     % Set them again to the new values.  From here on, we are safe,
  140.     % since a context switch will consult userparams.
  141.   .setuserparams
  142. } .bind odef
  143. % Initialize user parameters managed here.
  144. /JobName () .definepsuserparam
  145.  
  146. % Restore must restore the user parameters.
  147. % (Since userparams is in local VM, save takes care of saving them.)
  148. /restore {        % <save> restore -
  149.   //restore /userparams .systemvar .setuserparams
  150. } .bind odef
  151.  
  152. % The pssystemparams dictionary holds some system parameters that
  153. % are managed entirely at the PostScript level.
  154. systemdict begin
  155. currentdict /pssystemparams known not {
  156.   /pssystemparams 40 dict readonly def
  157. } if
  158. /getsystemparam {        % <name> getsystemparam <value>
  159.   //pssystemparams 1 index .knownget { exch pop } { .getsystemparam } ifelse
  160. } odef
  161. end
  162. /currentsystemparams {        % - currentsystemparams <dict>
  163.   mark .currentsystemparams //pssystemparams { } forall .dicttomark
  164. } odef
  165. /setsystemparams {        % <dict> setsystemparams -
  166.     % Check that we will be able to set the PostScript-level
  167.     % system parameters.
  168.    /SAFETY .systemvar /safe get {
  169.      % SAFER mode disallows some changes
  170.      [ /GenericResourceDir /FontResourceDir /GenericResourcePathSep ] {
  171.        2 copy .knownget {
  172.      exch //pssystemparams exch .knownget {
  173.            ne { /setsystemparams /invalidaccess signalerror } if
  174.          } {
  175.            pop
  176.          } ifelse
  177.        } {
  178.          pop
  179.        } ifelse
  180.      } forall
  181.    } if
  182.    /setsystemparams //pssystemparams mark exch {
  183.      type cvlit /.checkparamtype cvx 2 packedarray cvx
  184.    } forall .dicttomark .checksetparams
  185.     % Set the C-level system params.  If this succeeds, we know that
  186.     % the password check succeeded.
  187.    dup .setsystemparams
  188.     % Now set the PostScript-level params.  We must copy local strings
  189.     % into global VM.
  190.    dup
  191.     { //pssystemparams 2 index known
  192.        {        % Stack: key newvalue
  193.      .copyparam
  194.      //pssystemparams 3 1 roll .forceput    % pssystemparams is read-only
  195.        }
  196.        { pop pop
  197.        }
  198.       ifelse
  199.     }
  200.    forall pop
  201. } .bind odef
  202.  
  203. % Initialize the passwords.
  204. % NOTE: the names StartJobPassword and SystemParamsPassword are known to
  205. % the interpreter, and must be bound to noaccess strings.
  206. % The length of these strings must be max_password (iutil2.h) + 1.
  207. /StartJobPassword 65 string noaccess def
  208. /SystemParamsPassword 65 string noaccess def
  209.  
  210. % Redefine cache parameter setting to interact properly with userparams.
  211. /setcachelimit {
  212.   mark /MaxFontItem 2 index .dicttomark setuserparams pop
  213. } .bind odef
  214. /setcacheparams {
  215.     % The MaxFontCache parameter is a system parameter, which we might
  216.     % not be able to set.  Fortunately, this doesn't matter, because
  217.     % system parameters don't have to be synchronized between this code
  218.     % and the VM.
  219.   counttomark 1 add copy setcacheparams
  220.   currentcacheparams    % mark size lower upper
  221.     3 -1 roll pop
  222.     /MinFontCompress 3 1 roll
  223.     /MaxFontItem exch
  224.   .dicttomark setuserparams
  225.   cleartomark
  226. } .bind odef
  227.  
  228. % Add bogus user and system parameters to satisfy badly written PostScript
  229. % programs that incorrectly assume the existence of all the parameters
  230. % listed in Appendix C of the Red Book.  Note that some of these may become
  231. % real parameters later: code near the end of gs_init.ps takes care of
  232. % removing any such parameters from ps{user,system}params.
  233.  
  234. % psuserparams
  235.   /MaxFormItem 100000 .definepsuserparam
  236.   /MaxPatternItem 20000 .definepsuserparam
  237.   /MaxScreenItem 48000 .definepsuserparam
  238.   /MaxUPathItem 5000 .definepsuserparam
  239.  
  240. % File Access Permission parameters
  241.   .currentglobal true .setglobal
  242.   /.checkFilePermitparams {
  243.     type /arraytype eq {
  244.       currentuserparams /LockFilePermissions get {
  245.         5 { pop } repeat /setuserparams /invalidaccess signalerror
  246.       }
  247.       if
  248.     } {
  249.       5 { pop } repeat /setuserparams /typecheck signalerror
  250.     }
  251.     ifelse
  252.     true
  253.   } .bind def
  254. % Initialize the File Permission access control to wide open
  255. % These will only be accessed via current/set userparams.
  256. % Values are a string containing multiple nul terminated path strings
  257.   /PermitFileReading dup [ (*) ] .definepsuserparam
  258.     psuserparams exch /.checkFilePermitparams load put
  259.   /PermitFileWriting dup [ (*) ] .definepsuserparam
  260.     psuserparams exch /.checkFilePermitparams load put
  261.   /PermitFileControl dup [ (*) ] .definepsuserparam
  262.     psuserparams exch /.checkFilePermitparams load put
  263.   .setglobal
  264.  
  265. pssystemparams begin
  266.   /CurDisplayList 0 .forcedef
  267.   /CurFormCache 0 .forcedef
  268.   /CurOutlineCache 0 .forcedef
  269.   /CurPatternCache 0 .forcedef
  270.   /CurUPathCache 0 .forcedef
  271.   /CurScreenStorage 0 .forcedef
  272.   /CurSourceList 0 .forcedef
  273.   /DoPrintErrors false .forcedef
  274.   /MaxDisplayList 140000 .forcedef
  275.   /MaxFormCache 100000 .forcedef
  276.   /MaxOutlineCache 65000 .forcedef
  277.   /MaxPatternCache 100000 .forcedef
  278.   /MaxUPathCache 300000 .forcedef
  279.   /MaxScreenStorage 84000 .forcedef
  280.   /MaxSourceList 25000 .forcedef
  281.   /RamSize 4194304 .forcedef
  282. end
  283.  
  284. % Define the procedures for handling comment scanning.  The names
  285. % %ProcessComment and %ProcessDSCComment are known to the interpreter.
  286. % These procedures take the file and comment string and file as operands.
  287. /.checkprocesscomment {
  288.   dup null eq {
  289.     pop true
  290.   } {
  291.     dup xcheck {
  292.       type dup /arraytype eq exch /packedarraytype eq or
  293.     } {
  294.       pop false
  295.     } ifelse
  296.   } ifelse
  297. } .bind def
  298. /ProcessComment null .definepsuserparam
  299. psuserparams /ProcessComment {.checkprocesscomment} put
  300. (%ProcessComment) cvn {
  301.   /ProcessComment getuserparam
  302.   dup null eq { pop pop pop } { exec } ifelse
  303. } bind def
  304. /ProcessDSCComment null .definepsuserparam
  305. psuserparams /ProcessDSCComment {.checkprocesscomment} put
  306. (%ProcessDSCComment) cvn {
  307.   /ProcessDSCComment getuserparam
  308.   dup null eq { pop pop pop } { exec } ifelse
  309. } bind def
  310.  
  311. % ------ Miscellaneous ------ %
  312.  
  313. (<<) cvn            % - << -mark-
  314.   /mark load def
  315. (>>) cvn            % -mark- <key1> <value1> ... >> <dict>
  316.   /.dicttomark load def
  317. /languagelevel 2 def
  318. % When running in Level 2 mode, this interpreter is supposed to be
  319. % compatible with Adobe version 2017.
  320. /version (2017) readonly def
  321.  
  322. % If binary tokens are supported by this interpreter,
  323. % set an appropriate default binary object format.
  324. /setobjectformat where
  325.  { pop
  326.    /RealFormat getsystemparam (IEEE) eq { 1 } { 3 } ifelse
  327.    /ByteOrder getsystemparam { 1 add } if
  328.    setobjectformat
  329.  } if
  330.  
  331. % Aldus Freehand versions 2.x check for the presence of the
  332. % setcolor operator, and if it is missing, substitute a procedure.
  333. % Unfortunately, the procedure takes different parameters from
  334. % the operator.  As a result, files produced by this application
  335. % cause an error if the setcolor operator is actually defined
  336. % and 'bind' is ever used.  Aldus fixed this bug in Freehand 3.0,
  337. % but there are a lot of files created by the older versions
  338. % still floating around.  Therefore, at Adobe's suggestion,
  339. % we implement the following dreadful hack in the 'where' operator:
  340. %      If the key is /setcolor, and
  341. %        there is a dictionary named FreeHandDict, and
  342. %        currentdict is that dictionary,
  343. %      then "where" consults only that dictionary and not any other
  344. %        dictionaries on the dictionary stack.
  345. .wheredict /setcolor {
  346.   /FreeHandDict .where {
  347.     /FreeHandDict get currentdict eq {
  348.       pop currentdict /setcolor known { currentdict true } { false } ifelse
  349.     } {
  350.       .where
  351.     } ifelse
  352.   } {
  353.     .where
  354.   } ifelse
  355. } bind put
  356.  
  357. % ------ Virtual memory ------ %
  358.  
  359. /currentglobal            % - currentglobal <bool>
  360.   /currentshared load def
  361. /gcheck                % <obj> gcheck <bool>
  362.   /scheck load def
  363. /setglobal            % <bool> setglobal -
  364.   /setshared load def
  365. % We can make the global dictionaries very small, because they auto-expand.
  366. /globaldict currentdict /shareddict .knownget not { 4 dict } if def
  367. /GlobalFontDirectory SharedFontDirectory def
  368.  
  369. % VMReclaim and VMThreshold are user parameters.
  370. /setvmthreshold {        % <int> setvmthreshold -
  371.   mark /VMThreshold 2 index .dicttomark setuserparams pop
  372. } odef
  373. /vmreclaim {            % <int> vmreclaim -
  374.   dup 0 gt {
  375.     .vmreclaim
  376.   } {
  377.     mark /VMReclaim 2 index .dicttomark setuserparams pop
  378.   } ifelse
  379. } odef
  380. -1 setvmthreshold
  381.  
  382. % ------ IODevices ------ %
  383.  
  384. /.getdevparams where {
  385.   pop /currentdevparams {    % <iodevice> currentdevparams <dict>
  386.     .getdevparams .dicttomark
  387.   } odef
  388. } if
  389. /.putdevparams where {
  390.   pop /setdevparams {        % <iodevice> <dict> setdevparams -
  391.     mark 1 index { } forall counttomark 2 add index
  392.     .putdevparams pop pop
  393.   } odef
  394. } if
  395.  
  396. % ------ Job control ------ %
  397.  
  398. serverdict begin
  399.  
  400. % We could protect the job information better, but we aren't attempting
  401. % (currently) to protect ourselves against maliciousness.
  402.  
  403. /.jobsave null def        % top-level save object
  404. /.jobsavelevel 0 def        % save depth of job (0 if .jobsave is null,
  405.                 % 1 otherwise)
  406. /.adminjob true def        % status of current unencapsulated job
  407.  
  408. end        % serverdict
  409.  
  410. % Because there may be objects on the e-stack created since the job save,
  411. % we have to clear the e-stack before doing the end-of-job restore.
  412. % We do this by executing a 2 .stop, which is caught by the 2 .stopped
  413. % in .runexec; we leave on the o-stack a procedure to execute aftewards.
  414. %
  415. %**************** The definition of startjob is not complete yet, since
  416. % it doesn't reset stdin/stdout.
  417. /.startnewjob {            % <exit_bool> <password_level>
  418.                 %   .startnewjob -
  419.     serverdict /.jobsave get dup null eq { pop } { restore } ifelse
  420.     exch {
  421.             % Unencapsulated job
  422.       serverdict /.jobsave null put
  423.       serverdict /.jobsavelevel 0 put
  424.       serverdict /.adminjob 3 -1 roll 1 gt put
  425.         % The Adobe documentation doesn't say what happens to the
  426.         % graphics state stack in this case, but an experiment
  427.         % produced results suggesting that a grestoreall occurs.
  428.       grestoreall
  429.     } {
  430.             % Encapsulated job
  431.       pop
  432.       serverdict /.jobsave save put
  433.       serverdict /.jobsavelevel 1 put
  434.     } ifelse
  435.         % Reset the interpreter state.
  436.   clear cleardictstack
  437.   initgraphics
  438.   false setglobal
  439. } bind def
  440. /.startjob {            % <exit_bool> <password> <finish_proc>
  441.                 %   .startjob <ok_bool>
  442.   vmstatus pop pop serverdict /.jobsavelevel get eq
  443.   2 index .checkpassword 0 gt and {
  444.     exch .checkpassword exch count 3 roll count 3 sub { pop } repeat
  445.     cleardictstack
  446.         % Reset the e-stack back to the 2 .stopped in .runexec,
  447.         % passing the finish_proc to be executed afterwards.
  448.     2 .stop
  449.   } {        % Password check failed
  450.     pop pop pop false
  451.   } ifelse
  452. } odef
  453. /startjob {            % <exit_bool> <password> startjob <ok_bool>
  454.     % This is a hack.  We really need some way to indicate explicitly
  455.     % to the interpreter that we are under control of a job server.
  456.   .userdict /quit /stop load put
  457.   { .startnewjob true } .startjob
  458. } odef
  459.  
  460. systemdict begin
  461. /quit {                % - quit -
  462.   //systemdict begin serverdict /.jobsave get null eq
  463.    { end //quit }
  464.    { /quit load /invalidaccess /signalerror load end exec }
  465.   ifelse
  466. } bind odef
  467. end
  468.  
  469. % We would like to define exitserver as a procedure, using the code
  470. % that the Red Book says is equivalent to it.  However, since startjob
  471. % resets the exec stack, we can't do this, because control would never
  472. % proceed past the call on startjob if the exitserver is successful.
  473. % Instead, we need to construct exitserver out of pieces of startjob.
  474.  
  475. serverdict begin
  476.  
  477. /exitserver {            % <password> exitserver -
  478.   true exch { .startnewjob } .startjob not {
  479.     /exitserver /invalidaccess signalerror
  480.   } if
  481. } bind def
  482.  
  483. end        % serverdict
  484.  
  485. % ------ Compatibility ------ %
  486.  
  487. % In Level 2 mode, the following replace the definitions that gs_statd.ps
  488. % installs in statusdict and serverdict.
  489. % Note that statusdict must be allocated in local VM.
  490. % We don't bother with many of these yet.
  491.  
  492. /.dict1 { exch mark 3 1 roll .dicttomark } bind def
  493.  
  494. currentglobal false setglobal 25 dict exch setglobal begin
  495. currentsystemparams
  496.  
  497. % The following do not depend on the presence of setpagedevice.
  498. /buildtime 1 index /BuildTime get def
  499. /byteorder 1 index /ByteOrder get def
  500. /checkpassword { .checkpassword 0 gt } bind def
  501. dup /DoStartPage known
  502.  { /dostartpage { /DoStartPage getsystemparam } bind def
  503.    /setdostartpage { /DoStartPage .dict1 setsystemparams } bind def
  504.  } if
  505. dup /StartupMode known
  506.  { /dosysstart { /StartupMode getsystemparam 0 ne } bind def
  507.    /setdosysstart { { 1 } { 0 } ifelse /StartupMode .dict1 setsystemparams } bind def
  508.  } if
  509. %****** Setting jobname is supposed to set userparams.JobName, too.
  510. /jobname { /JobName getuserparam } bind def
  511. /jobtimeout { /JobTimeout getuserparam } bind def
  512. /ramsize { /RamSize getsystemparam } bind def
  513. /realformat 1 index /RealFormat get def
  514. dup /PrinterName known
  515.  { /setprintername { /PrinterName .dict1 setsystemparams } bind def
  516.  } if
  517. /printername
  518.  { currentsystemparams /PrinterName .knownget not { () } if exch copy
  519.  } bind def
  520. currentuserparams /WaitTimeout known
  521.  { /waittimeout { /WaitTimeout getuserparam } bind def
  522.  } if
  523.  
  524. % The following do require setpagedevice.
  525. /.setpagedevice where { pop } { (%END PAGEDEVICE) .skipeof } ifelse
  526. /defaulttimeouts
  527.  { currentsystemparams dup
  528.    /JobTimeout .knownget not { 0 } if
  529.    exch /WaitTimeout .knownget not { 0 } if
  530.    currentpagedevice /ManualFeedTimeout .knownget not { 0 } if
  531.  } bind def
  532. /margins
  533.  { currentpagedevice /Margins .knownget { exch } { [0 0] } ifelse
  534.  } bind def
  535. /pagemargin
  536.  { currentpagedevice /PageOffset .knownget { 0 get } { 0 } ifelse
  537.  } bind def
  538. /pageparams
  539.  { currentpagedevice
  540.    dup /Orientation .knownget { 1 and ORIENT1 { 1 xor } if } { 0 } ifelse exch
  541.    dup /PageSize get aload pop 3 index 0 ne { exch } if 3 2 roll
  542.    /PageOffset .knownget { 0 get } { 0 } ifelse 4 -1 roll
  543.  } bind def
  544. /setdefaulttimeouts
  545.  { exch mark /ManualFeedTimeout 3 -1 roll
  546.    /Policies mark /ManualFeedTimeout 1 .dicttomark
  547.    .dicttomark setpagedevice
  548.    /WaitTimeout exch mark /JobTimeout 5 2 roll .dicttomark setsystemparams
  549.  } bind def
  550. /.setpagesize { 2 array astore /PageSize .dict1 setpagedevice } bind def
  551. /setduplexmode { /Duplex .dict1 setpagedevice } bind def
  552. /setmargins
  553.  { exch 2 array astore /Margins .dict1 setpagedevice
  554.  } bind def
  555. /setpagemargin { 0 2 array astore /PageOffset .dict1 setpagedevice } bind def
  556. /setpageparams
  557.  { mark /PageSize 6 -2 roll
  558.    4 index 1 and ORIENT1 { 1 } { 0 } ifelse ne { exch } if 2 array astore
  559.    /Orientation 5 -1 roll ORIENT1 { 1 xor } if
  560.    /PageOffset counttomark 2 add -1 roll 0 2 array astore
  561.    .dicttomark setpagedevice
  562.  } bind def
  563. /setresolution
  564.  { dup 2 array astore /HWResolution .dict1 setpagedevice
  565.  } bind def
  566. %END PAGEDEVICE
  567.  
  568. % The following are not implemented yet.
  569. %manualfeed
  570. %manualfeedtimeout
  571. %pagecount
  572. %pagestackorder
  573. %setpagestackorder
  574.  
  575. pop        % currentsystemparams
  576.  
  577. % Flag the current dictionary so it will be swapped when we
  578. % change language levels.  (See zmisc2.c for more information.)
  579. /statusdict currentdict def
  580.  
  581. currentdict end
  582. /statusdict exch .forcedef    % statusdict is local, systemdict is global
  583.  
  584. % The following compatibility operators are in systemdict.  They are
  585. % defined here, rather than in gs_init.ps, because they require the
  586. % resource machinery.
  587.  
  588. /devforall {        % <pattern> <proc> <scratch> devforall -
  589.   exch {
  590.     1 index currentdevparams
  591.     /Type .knownget { /FileSystem eq } { false } ifelse
  592.     { exec } { pop pop } ifelse
  593.   } /exec load 3 packedarray cvx exch
  594.   (*) 3 1 roll ppstack flush /IODevice resourceforall
  595. } odef
  596. /devstatus {        % <(%disk*%)> devstatus <searchable> <writable>
  597.             %   <hasNames> <mounted> <removable> <searchOrder>
  598.             %   <freePages> <size> true
  599.             % <string> devstatus false
  600.   dup length 5 ge {
  601.     dup 0 5 getinterval (%disk) eq {
  602.       dup /IODevice resourcestatus {
  603.     pop pop dup currentdevparams
  604.     dup /Searchable get
  605.     exch dup /Writable get
  606.     exch dup /HasNames get
  607.     exch dup /Mounted get
  608.     exch dup /Removable get
  609.     exch dup /SearchOrder get
  610.     exch dup /Free get
  611.     exch /LogicalSize get
  612.     9 -1 roll pop true
  613.       } {
  614.     pop false
  615.       } ifelse
  616.     } {
  617.       pop false
  618.     } ifelse
  619.   } {
  620.     pop false
  621.   } ifelse
  622. } odef
  623.  
  624. % ------ Color spaces ------ %
  625.  
  626. % Attempt to convert a tint transformation procedure to a type 4 Function.
  627. % The value <m> is the number  of function inputs
  628. % The current color space defines the number of function output values.
  629. % The current color space will be the alternate color space for the function.
  630. % If the conversion fails then build a color cube function.
  631.  
  632. /.converttinttransform {    % [.. .. .. proc ] <m>
  633.                 %   .converttinttransform [.. .. .. proc']
  634.   .currentglobal            % Save current global memory state
  635.   2 index gcheck .setglobal        % Set gobal mode to match the array's mode
  636.   4 dict                % Build a dictionary for our type 4 function
  637.     dup /FunctionType 4 put        % Set FunctionType
  638.     dup /Function 5 index 3 get put    % Set function expression
  639.         % Stack: orig m global func
  640.     dup /Domain
  641.     [ 5 index {0 1} repeat ] put    % set Domain values
  642.     dup /Range
  643.     [ mark currentcolor counttomark
  644.     dup 2 add 1 roll cleartomark    % # of components in alternate space
  645.     {0 1} repeat ] put            % Set Range values
  646.   { .buildfunction } .internalstopped    % Try to build a type 4 function
  647.   dup
  648.   {                % type 4 function failed - Collect data for a color cube
  649.     pop                    % Remove duplicate copy of stopped status
  650.     pop                    % Remove invalid type 4 function
  651.     1 index                % Get number of inputs
  652.     mark currentcolor counttomark    % Count number of output colors
  653.     dup 2 add 1 roll cleartomark    % # of components in alternate space
  654.     4 index 3 get            % Get tint transform function
  655.     { .buildcolorcube } .internalstopped 
  656.   } if
  657.   {                    % Color cube build failed
  658.     pop pop pop exch pop exch pop    % Remove unused parameters
  659.     .setglobal                % Restore global state
  660.   } {                    % Function build succeeded - install function
  661.                     % Stack: orig m global func
  662.     3 -1 roll pop            % Stack: orig global func
  663.     2 index 4 array copy dup 3 4 -1 roll put
  664.     exch .setglobal exch pop
  665.   } ifelse
  666. } bind def
  667.  
  668. % Define the setcolorspace procedures:
  669. %    <colorspace> proc <colorspace'|null>
  670. % We have to define the dictionary first, so it can be bound into the
  671. % implementation procedure, but we can't populate it until the procedure
  672. % has been defined, so that the procedure can get bound into recursive calls.
  673. /colorspacedict 20 dict def
  674.  
  675. /.devcs [
  676.   /DeviceGray /DeviceRGB /DeviceCMYK /DevicePixel
  677. ] readonly def
  678. /currentcolorspace {        % - currentcolorspace <array>
  679.   .currentcolorspace dup type /integertype eq {
  680.     //.devcs exch 1 getinterval
  681.   } if
  682. } odef
  683. currentdict /.devcs .undef
  684.  
  685. /setcolorspace {        % <name|array> setcolorspace -
  686.   dup dup dup type /nametype ne { 0 get } if
  687.   //colorspacedict exch get exec
  688.   dup null eq { pop } { .setcolorspace } ifelse pop
  689. } odef
  690.  
  691. colorspacedict
  692.   dup /DeviceGray { pop 0 setgray null } bind put
  693.   dup /DeviceRGB { pop 0 0 0 setrgbcolor null } bind put
  694.   /setcmykcolor where
  695.    { pop dup /DeviceCMYK { pop 0 0 0 1 setcmykcolor null } bind put
  696.    } if
  697.   /.setcieaspace where
  698.    { pop dup /CIEBasedA { NOCIE { pop 0 setgray null } { dup 1 get .setcieaspace } ifelse } bind put
  699.    } if
  700.   /.setcieabcspace where
  701.    { pop dup /CIEBasedABC { NOCIE { pop 0 0 0 setrgbcolor null } { dup 1 get .setcieabcspace } ifelse } bind put
  702.    } if
  703.   /.setciedefspace where
  704.    { pop dup /CIEBasedDEF { NOCIE { pop 0 0 0 setrgbcolor null } { dup 1 get .setciedefspace } ifelse } bind put
  705.    } if
  706.   /.setciedefgspace where
  707.    { pop dup /CIEBasedDEFG { NOCIE { pop 0 0 0 1 setcmykcolor null } { dup 1 get .setciedefgspace } ifelse } bind put
  708.    } if
  709.   /.setseparationspace where
  710.    { pop dup /Separation { dup 2 get setcolorspace dup 1 .converttinttransform .setseparationspace } bind put
  711.    } if
  712.   /.setindexedspace where
  713.    { pop dup /Indexed { dup 1 get setcolorspace dup .setindexedspace } bind put
  714.    } if
  715.   /.nullpatternspace [/Pattern] readonly def
  716.   /.setpatternspace where
  717.    { pop dup /Pattern
  718.       { dup type /nametype eq { pop //.nullpatternspace } if
  719.     dup length 1 gt { dup 1 get setcolorspace } if
  720.         dup .setpatternspace
  721.       } bind put
  722.    } if
  723.     % If DeviceN space is included, gs_ll3.ps registers it.
  724.   /.setdevicepixelspace where
  725.    { pop dup /DevicePixel { dup .setdevicepixelspace } bind put
  726.    } if
  727.   currentdict /.nullpatternspace .undef
  728. pop
  729.  
  730. % ------ CIE color rendering ------ %
  731.  
  732. % Define findcolorrendering and a default ColorRendering ProcSet.
  733.  
  734. /findcolorrendering {        % <intentname> findcolorrendering
  735.                 %   <crdname> <found>
  736.   /ColorRendering /ProcSet findresource
  737.   1 index .namestring (.) concatstrings
  738.   1 index /GetPageDeviceName get exec .namestring (.) concatstrings
  739.   2 index /GetHalftoneName get exec .namestring
  740.   concatstrings concatstrings
  741.   dup /ColorRendering resourcestatus {
  742.     pop pop exch pop exch pop true
  743.   } {
  744.     pop /GetSubstituteCRD get exec false
  745.   } ifelse
  746. } odef
  747.  
  748. 5 dict dup begin
  749.  
  750. /GetPageDeviceName {        % - GetPageDeviceName <name>
  751.   currentpagedevice dup /PageDeviceName .knownget {
  752.     exch pop dup null eq { pop /none } if
  753.   } {
  754.     pop /none
  755.   } ifelse
  756. } bind def
  757.  
  758. /GetHalftoneName {        % - GetHalftoneName <name>
  759.   currenthalftone /HalftoneName .knownget not { /none } if
  760. } bind def
  761.  
  762. /GetSubstituteCRD {        % <intentname> GetSubstituteCRD <crdname>
  763.   pop /DefaultColorRendering
  764. } bind def
  765.  
  766. end
  767. % The resource machinery hasn't been activated, so just save the ProcSet
  768. % and let .fixresources finish the installation process.
  769. /ColorRendering exch def
  770.  
  771. % Define setcolorrendering.
  772.  
  773. /.colorrenderingtypes 5 dict def
  774.  
  775. /setcolorrendering {        % <crd> setcolorrendering -
  776.   dup /ColorRenderingType get //.colorrenderingtypes exch get exec
  777. } odef
  778.  
  779. /.setcolorrendering1 where { pop } { (%END CRD) .skipeof } ifelse
  780.  
  781. .colorrenderingtypes 1 {
  782.   dup .buildcolorrendering1 .setcolorrendering1
  783. } .bind put
  784.  
  785. % Note: the value 101 in the next line must be the same as the value of
  786. % GX_DEVICE_CRD1_TYPE in gscrdp.h.
  787. .colorrenderingtypes 101 {
  788.   dup .builddevicecolorrendering1 .setdevicecolorrendering1
  789. } .bind put
  790.  
  791. % Initialize the default CIE rendering dictionary.
  792. % The most common CIE files seem to assume the "calibrated RGB color space"
  793. % described on p. 189 of the PostScript Language Reference Manual,
  794. % 2nd Edition; we simply invert this transformation back to RGB.
  795. mark
  796.    /ColorRenderingType 1
  797. % We must make RangePQR and RangeLMN large enough so that values computed by
  798. % the assumed encoding MatrixLMN don't get clamped.
  799.    /RangePQR [0 0.9505 0 1 0 1.0890] readonly
  800. % This TransformPQR implements a relative colorimetric intent by scaling
  801. % the XYZ values relative to the white and black points.
  802.    /TransformPQR
  803.      [ { 5 1 roll                    % p Ws Bs Wd Bd
  804.          4 {3 get 5 1 roll} repeat   % ws bs wd bd p 
  805.          3 index sub                 % ws bs wd bd p-bs 
  806.          1 index                     % ws bs wd bd p-bs bd
  807.          6 2 roll                    % p-bs bd ws bs wd bd 
  808.          sub                         % p-bs bd ws bs wd-bd 
  809.          5 1 roll                    % wd-bd p-bs bd ws bs  
  810.          sub                         % wd-bd p-bs bd ws-bs  
  811.          4 2 roll                    % bd ws-bs wd-bd p-bs 
  812.          mul                         % bd ws-bs (wd-bd)*(p-bs)
  813.          exch div add                % bd + (wd-bd)*(p-bs)/(ws-bs)
  814.        } bind
  815.        { 5 1 roll
  816.          4 {4 get 5 1 roll} repeat
  817.          3 index sub 1 index 6 2 roll sub 5 1 roll
  818.          sub 4 2 roll mul exch div add
  819.        } bind
  820.        { 5 1 roll
  821.          4 {5 get 5 1 roll} repeat
  822.          3 index sub 1 index 6 2 roll sub 5 1 roll
  823.          sub 4 2 roll mul exch div add
  824.        } bind
  825.      ] readonly
  826.    /RangeLMN [0 0.9505 0 1 0 1.0890] readonly
  827.    /MatrixABC
  828.     [ 3.24063 -0.96893  0.05571
  829.      -1.53721  1.87576 -0.20402
  830.      -0.49863  0.04152  1.05700
  831.     ] readonly
  832.    /EncodeABC [ {0 .max 0.45 exp} bind dup dup] readonly
  833.    /WhitePoint [0.9505 1 1.0890] readonly
  834.     % Some Genoa tests seem to require the presence of BlackPoint.
  835.    /BlackPoint [0 0 0] readonly
  836. .dicttomark setcolorrendering
  837.  
  838. %END CRD
  839.  
  840. % Initialize a CIEBased color space for sRGB.
  841. /CIEsRGB [ /CIEBasedABC
  842.   mark
  843.     /DecodeLMN [ {
  844.       dup 0.03928 le { 12.92321 div } { 0.055 add 1.055 div 2.4 exp } ifelse
  845.     } bind dup dup ] readonly
  846.     /MatrixLMN [
  847.       0.412457 0.212673 0.019334
  848.       0.357576 0.715152 0.119192
  849.       0.180437 0.072175 0.950301
  850.     ] readonly
  851.     /WhitePoint [0.9505 1.0 1.0890] readonly
  852.   .dicttomark readonly
  853. ] readonly def
  854.  
  855. % ------ Painting ------ %
  856.  
  857. % A straightforward definition of execform that doesn't actually
  858. % do any caching.
  859. /.execform1 {
  860.     % This is a separate operator so that the stacks will be restored
  861.     % properly if an error occurs.
  862.   dup /Matrix get concat
  863.   dup /BBox get aload pop
  864.   exch 3 index sub exch 2 index sub rectclip
  865.   dup /PaintProc get
  866.   1 index /Implementation known not {
  867.     1 index dup /Implementation null .forceput readonly pop
  868.   } if
  869.   exec
  870. } .bind odef    % must bind .forceput
  871.  
  872. /.formtypes 5 dict
  873.   dup 1 /.execform1 load put
  874. def
  875.  
  876. /execform {            % <form> execform -
  877.   gsave {
  878.     dup /FormType get //.formtypes exch get exec
  879.   } stopped grestore { stop } if
  880. } odef
  881.  
  882. /.patterntypes 5 dict
  883.   dup 1 /.buildpattern1 load put
  884. def
  885.  
  886. /makepattern {            % <proto_dict> <matrix> makepattern <pattern>
  887.   //.patterntypes 2 index /PatternType get get
  888.   .currentglobal false .setglobal exch
  889.         % Stack: proto matrix global buildproc
  890.   3 index dup length 1 add dict .copydict
  891.   3 index 3 -1 roll exec 3 -1 roll .setglobal
  892.   1 index /Implementation 3 -1 roll put
  893.   readonly exch pop exch pop
  894. } odef
  895.  
  896. /setpattern {            % [<comp1> ...] <pattern> setpattern -
  897.   currentcolorspace 0 get /Pattern ne {
  898.     [ /Pattern currentcolorspace ] setcolorspace
  899.   } if setcolor
  900. } odef
  901.  
  902. % Extend image and imagemask to accept dictionaries.
  903. % We must create .imagetypes and .imagemasktypes outside level2dict,
  904. % and leave some extra space because we're still in Level 1 mode.
  905. systemdict begin
  906. /.imagetypes 5 dict
  907.   dup 1 /.image1 load put
  908. def
  909. /.imagemasktypes 5 dict
  910.   dup 1 /.imagemask1 load put
  911. def
  912. end
  913.  
  914. /.image /image load def
  915. /image {
  916.   dup type /dicttype eq {
  917.     dup /ImageType get //.imagetypes exch get exec
  918.   } {
  919.     //.image
  920.   } ifelse
  921. } odef
  922. currentdict /.image undef
  923.  
  924. /.imagemask /imagemask load def
  925. /imagemask {
  926.   dup type /dicttype eq {
  927.     dup /ImageType get //.imagemasktypes exch get exec
  928.   } {
  929.     //.imagemask
  930.   } ifelse
  931. } odef
  932. currentdict /.imagemask undef
  933.  
  934. end                % level2dict
  935.